/**
 * 游戏应用管理器
 * 
 * 职责：
 * 1. 管理整个游戏的初始化流程
 * 2. 协调 ECS 和 MVVM 的初始化顺序
 * 3. 管理游戏的生命周期（启动、暂停、恢复、重启）
 * 4. 驱动 ECS 系统的更新
 * 5. 提供全局游戏状态访问接口
 * 
 * @author AI Assistant
 * @date 2025-11-26
 */

import { Node } from "cc";
import { ecs } from "../core/ecs/ECS";
import { Log } from "../core/logger/LoggerGlobal";

// 导入类型（用于依赖注入）
import type { SceneCoordinator } from "./coordinator/SceneCoordinator";
import type { WorldSystem } from "./ecs/worldSystem";
import type { FixedUpdateManager } from "./ecs/FixedUpdateManager";
import type { CommandQueue } from "./ecs/command/CommandQueue";

/**
 * 游戏状态枚举
 */
export enum GameState {
    /** 未初始化 */
    UNINITIALIZED = 'uninitialized',
    /** 初始化中 */
    INITIALIZING = 'initializing',
    /** 已初始化 */
    INITIALIZED = 'initialized',
    /** 运行中 */
    RUNNING = 'running',
    /** 已暂停 */
    PAUSED = 'paused',
    /** 已停止 */
    STOPPED = 'stopped'
}

/**
 * 初始化选项
 */
export interface InitializeOptions {
    /** 是否预热对象池 */
    warmupPools?: boolean;
    /** 是否启用调试模式 */
    debugMode?: boolean;
    /** 自定义场景层级 */
    customLayers?: any[];
}

/**
 * 游戏统计信息
 */
export interface GameStatistics {
    state: GameState;
    runningTime: number; // 运行时间（秒）
    frameCount: number; // 帧数
    averageFPS: number; // 平均 FPS
    ecsStats: any; // ECS 统计信息
    sceneStats: any; // 场景统计信息
}

/**
 * 游戏应用管理器类（使用依赖注入）
 */
export class GameApplication {
    // ========== 状态管理 ==========
    
    /** 当前游戏状态 */
    private _state: GameState = GameState.UNINITIALIZED;
    
    /** 是否启用调试模式 */
    private _debugMode: boolean = false;
    
    // ========== 统计数据 ==========
    
    /** 游戏开始时间 */
    private startTime: number = 0;
    
    /** 运行时间（秒） */
    private runningTime: number = 0;
    
    /** 帧数计数 */
    private frameCount: number = 0;
    
    /** FPS 采样数组 */
    private fpsSamples: number[] = [];
    
    /** 最大 FPS 采样数 */
    private readonly MAX_FPS_SAMPLES = 60;
    
    /**
     * 构造函数 - 依赖注入
     */
    constructor(
        private ecsWorld: WorldSystem,
        private sceneCoordinator: SceneCoordinator,
        private fixedUpdateManager: FixedUpdateManager,
        private commandQueue: CommandQueue
    ) {
        Log.game.debug('GameApplication 已创建（DI）');
    }
    
    /**
     * 初始化游戏应用
     * @param sceneRoot 场景根节点
     * @param options 初始化选项
     */
    async initialize(sceneRoot: Node, options?: InitializeOptions): Promise<void> {
        if (this._state !== GameState.UNINITIALIZED) {
            Log.game.warn('游戏已初始化，跳过重复初始化');
            return;
        }
        
        this._state = GameState.INITIALIZING;
        
        Log.game.info('🚀 开始初始化游戏应用...');
        
        // 设置调试模式
        this._debugMode = options?.debugMode || false;
        
        try {
            // 1. 初始化场景协调器
            await this.initializeSceneCoordinator(sceneRoot, options);
            
            // 2. 初始化 ECS 系统
            await this.initializeECS();
            
            // 3. 预热对象池（可选）
            if (options?.warmupPools) {
                await this.warmupPools();
            }
            
            this._state = GameState.INITIALIZED;
            
            Log.game.info('✅ 游戏应用初始化完成');
            
            if (this._debugMode) {
                this.printInitializationInfo();
            }
        } catch (error) {
            Log.game.error('❌ 初始化失败', { error });
            this._state = GameState.UNINITIALIZED;
            throw error;
        }
    }
    
    /**
     * 初始化场景协调器
     */
    private async initializeSceneCoordinator(sceneRoot: Node, options?: InitializeOptions): Promise<void> {
        Log.scene.info('初始化场景协调器...');
        
        this.sceneCoordinator.init(sceneRoot, options?.customLayers);
        
        Log.scene.info('✅ 场景协调器初始化完成');
    }
    
    /**
     * 初始化 ECS 系统
     */
    private async initializeECS(): Promise<void> {
        Log.ecs.info('初始化 ECS 系统...');
        
        // 初始化 ECS 根系统
        this.ecsWorld.init();
        
        Log.ecs.info('✅ ECS 系统初始化完成');
        
        if (this._debugMode) {
            ecs.printStatistics();
        }
    }
    
    /**
     * 预热对象池
     */
    private async warmupPools(): Promise<void> {
        Log.ecs.info('预热对象池...');
        
        // 这里可以预热常用的实体和组件
        // 示例：
        // ecs.warmupEntityPool(Player, 10);
        // ecs.warmupComponentPool(PositionComponent, 100);
        
        Log.ecs.info('✅ 对象池预热完成');
    }
    
    /**
     * 启动游戏
     */
    start(): void {
        if (this._state !== GameState.INITIALIZED) {
            Log.game.error('游戏未初始化，无法启动');
            return;
        }
        
        this._state = GameState.RUNNING;
        this.startTime = Date.now();
        this.runningTime = 0;
        this.frameCount = 0;
        
        Log.game.info('🎮 游戏开始运行');
        
        if (this._debugMode) {
            this.startPerformanceMonitoring();
        }
    }
    
    /**
     * 游戏更新（每帧调用）
     * @param dt 帧间隔时间（秒）
     */
    update(dt: number): void {
        if (this._state !== GameState.RUNNING) {
            return;
        }
        
        // 更新运行时间
        this.runningTime += dt;
        this.frameCount++;
        
        // 记录 FPS
        if (dt > 0) {
            const fps = 1 / dt;
            this.fpsSamples.push(fps);
            if (this.fpsSamples.length > this.MAX_FPS_SAMPLES) {
                this.fpsSamples.shift();
            }
        }
        
        // 执行 ECS 系统更新
        try {
            this.ecsWorld.execute(dt);
        } catch (error) {
            Log.ecs.error('ECS 更新失败', { error });
        }
    }
    
    /**
     * 暂停游戏
     */
    pause(): void {
        if (this._state !== GameState.RUNNING) {
            Log.game.warn('游戏不在运行状态，无法暂停');
            return;
        }
        
        this._state = GameState.PAUSED;
        
        Log.game.info('⏸️ 游戏暂停');
    }
    
    /**
     * 恢复游戏
     */
    resume(): void {
        if (this._state !== GameState.PAUSED) {
            Log.game.warn('游戏不在暂停状态，无法恢复');
            return;
        }
        
        this._state = GameState.RUNNING;
        
        Log.game.info('▶️ 游戏恢复');
    }
    
    /**
     * 停止游戏
     */
    stop(): void {
        if (this._state === GameState.UNINITIALIZED || 
            this._state === GameState.INITIALIZING) {
            return;
        }
        
        this._state = GameState.STOPPED;
        
        Log.game.info('🛑 游戏停止');
    }
    
    /**
     * 重启游戏
     */
    async restart(): Promise<void> {
        Log.game.info('🔄 游戏重启');
        
        // 清理 ECS
        ecs.clear();
        
        // 清理场景
        this.sceneCoordinator.clearAllLayers();
        
        // 重新初始化 ECS
        await this.initializeECS();
        
        // 重置统计数据
        this.startTime = Date.now();
        this.runningTime = 0;
        this.frameCount = 0;
        this.fpsSamples = [];
        
        // 恢复运行状态
        this._state = GameState.RUNNING;
        
        Log.game.info('✅ 游戏重启完成');
    }
    
    /**
     * 销毁游戏应用
     */
    destroy(): void {
        Log.game.info('💥 销毁游戏应用');
        
        this.stop();
        
        // 清理 ECS
        this.ecsWorld.clear();
        ecs.clear();
        
        // 清理场景协调器
        this.sceneCoordinator.destroy();
        
        // 重置状态
        this._state = GameState.UNINITIALIZED;
        this.runningTime = 0;
        this.frameCount = 0;
        this.fpsSamples = [];
        
        Log.game.info('✅ 游戏应用已销毁');
    }
    
    /**
     * 获取 ECS 世界
     */
    getECSWorld(): WorldSystem {
        return this.ecsWorld;
    }
    
    /**
     * 获取场景协调器
     */
    getSceneCoordinator(): SceneCoordinator {
        return this.sceneCoordinator;
    }
    
    /**
     * 获取当前游戏状态
     */
    getState(): GameState {
        return this._state;
    }
    
    /**
     * 检查是否正在运行
     */
    isRunning(): boolean {
        return this._state === GameState.RUNNING;
    }
    
    /**
     * 检查是否已暂停
     */
    isPaused(): boolean {
        return this._state === GameState.PAUSED;
    }
    
    /**
     * 检查是否已初始化
     */
    isInitialized(): boolean {
        return this._state !== GameState.UNINITIALIZED && 
               this._state !== GameState.INITIALIZING;
    }
    
    /**
     * 获取运行时间（秒）
     */
    getRunningTime(): number {
        return this.runningTime;
    }
    
    /**
     * 获取帧数
     */
    getFrameCount(): number {
        return this.frameCount;
    }
    
    /**
     * 获取平均 FPS
     */
    getAverageFPS(): number {
        if (this.fpsSamples.length === 0) return 0;
        
        const sum = this.fpsSamples.reduce((acc, fps) => acc + fps, 0);
        return sum / this.fpsSamples.length;
    }
    
    /**
     * 获取统计信息
     */
    getStatistics(): GameStatistics {
        return {
            state: this._state,
            runningTime: this.runningTime,
            frameCount: this.frameCount,
            averageFPS: this.getAverageFPS(),
            ecsStats: ecs.getStatistics(),
            sceneStats: this.sceneCoordinator.getStatistics()
        };
    }
    
    /**
     * 打印统计信息
     */
    printStatistics(): void {
        const stats = this.getStatistics();
        
        Log.performance.info('\n=== 游戏应用统计信息 ===');
        Log.performance.info(`游戏状态: ${stats.state}`);
        Log.performance.info(`运行时间: ${stats.runningTime.toFixed(2)} 秒`);
        Log.performance.info(`总帧数: ${stats.frameCount}`);
        Log.performance.info(`平均 FPS: ${stats.averageFPS.toFixed(2)}`);
        Log.performance.info('');
        
        // ECS 统计
        ecs.printStatistics();
        
        // 场景统计
        this.sceneCoordinator.printStatistics();
    }
    
    /**
     * 打印初始化信息
     */
    private printInitializationInfo(): void {
        Log.game.info('\n=== 游戏初始化信息 ===');
        Log.game.info(`调试模式: ${this._debugMode ? '开启' : '关闭'}`);
        Log.game.info(`游戏状态: ${this._state}`);
        Log.game.info('');
    }
    
    /**
     * 启动性能监控
     */
    private startPerformanceMonitoring(): void {
        // 每 5 秒打印一次统计信息
        setInterval(() => {
            if (this._state === GameState.RUNNING) {
                this.printStatistics();
            }
        }, 5000);
    }
    
    /**
     * 启用调试模式
     */
    enableDebugMode(): void {
        this._debugMode = true;
        Log.game.info('调试模式已启用');
    }
    
    /**
     * 禁用调试模式
     */
    disableDebugMode(): void {
        this._debugMode = false;
        Log.game.info('调试模式已禁用');
    }
    
    /**
     * 检查是否为调试模式
     */
    isDebugMode(): boolean {
        return this._debugMode;
    }
}

/**
 * 使用说明：
 * 
 * GameApplication 现在使用依赖注入，不再是单例。
 * 
 * 通过 DI 容器获取实例：
 * ```typescript
 * import { container, ServiceIdentifiers } from '../core/di';
 * const gameApp = container.resolve<GameApplication>(ServiceIdentifiers.GameApplication);
 * ```
 * 
 * 或使用 bootstrap 辅助函数：
 * ```typescript
 * import { getService } from './bootstrap';
 * import { ServiceIdentifiers } from '../core/di';
 * const gameApp = getService<GameApplication>(ServiceIdentifiers.GameApplication);
 * ```
 */
